Simultaneously achieving efficiency and flexibility in enterprise software production has been a considerable challenge for firms. Newer software development paradigms such as component-based and model-driven development attempt to overcome this challenge by emphasizing modular design of complex systems. However, there is a paucity of rigorous empirical research on the use of such software methodologies and the associated extent to which trade-offs between efficiency and flexibility can be influenced. Addressing this gap, we investigate the performance outcomes of a model-driven, component-based software development methodology using data collected from an enterprise software development firm that deployed such a methodology for its product development processes. Examining the design, development, and implementation of 92 business software components of the firm's enterprise resource planning product, we discuss how the design of software components, specifically component granularity, affects development efficiency (development effort and defects) and flexibility (customization effort). Our results suggest that (a) components that are coarse grained are associated with higher flexibility (lower customization effort) but are also associated with lower development efficiency (more development effort and defects), and (b) defect proneness of a component plays a mediating role on the relationship between component granularity and flexibility. These findings present strong evidence for the existence of trade-offs between efficiency and flexibility in mass-customized software product life cycles. They establish component granularity as a key design dimension that needs to be managed judiciously to enable potential trade-off shifting mechanisms through the use of software methodologies that emphasize modular design approaches.
The complexity and scope of outsourced information technology (IT) demands relationship-specific investments from vendors, which, when combined with contract incompleteness, may result in underinvestment and inefficient bargaining, referred to as the holdup problem. Using a unique data set of over 100 IT outsourcing contracts, we examine whether contract extensiveness, i.e., the extent to which firms and vendors can foresee contingencies when designing contracts for outsourced IT services, can alleviate holdup. While extensively detailed contracts are likely to include a greater breadth of activities outsourced to a vendor, task complexity makes it difficult to draft extensive contracts. Furthermore, extensive contracts may still be incomplete with respect to enforcement. We then examine the role of nonprice contractual provisions, contract duration, and extendibility terms, which give firms an option to extend the contract to limit the likelihood of holdup. We also validate the ex post efficiency of contract design choices by examining renewals of contracting agreements.